﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
using System.Management;
using System.IO;

namespace Snowy
{
    // 主窗体类，继承自Form类
    public partial class Form1 : Form
    {
        // 用于SetBits方法的句柄状态标志
        bool haveHandle = true;
        // 用于窗体拖拽功能的标志
        bool bFormDragging = false;
        // 记录鼠标点击位置，用于窗体拖拽
        Point oPointClicked;

        // 拖拽动画帧计数器
        int dragFrame = 0;
        // 眨眼动画帧计数器
        int blinkFrame = 0;
        // 帽子编号，-1表示不戴帽子
        int hatNum = -1;
        // 衣服编号，-1表示不穿衣服
        int clothesNum = -1;

        // 系统信息相关字段
        private PerformanceCounter cpuCounter;
        private Timer systemInfoTimer;
        private bool showSystemInfo = false;
        // 系统信息显示相关字段
        private bool showSystemInfoOverlay = false;
        private string currentSystemInfo = "";
        // 系统信息显示窗体
        private Form systemInfoForm;
        private Label systemInfoLabel;

        // 亮度调节定时器
        private Timer brightnessTimer;
        // 自动亮度调节开关状态
        private bool autoBrightnessEnabled = false;
        // 时间段枚举，用于亮度调节
        private enum TimePeriod { Morning = 0, Noon = 1, Evening = 2, Night = 3 };

        // 宠物状态枚举：普通状态和拖拽状态
        private enum PetStates { General = 0, Drag = 1 };

        // 存储宠物普通状态图片的数组（30帧）
        Bitmap[] pet = new Bitmap[30];
        // 存储宠物拖拽状态图片的数组（3帧）
        Bitmap[] petDrag = new Bitmap[3];
        // 存储宠物眨眼状态图片的数组（2帧）
        Bitmap[] petBlink = new Bitmap[2];

        // 存储帽子图片的二维数组（10种帽子，每种2个状态）
        Bitmap[,] petHat = new Bitmap[10, 2];
        // 存储衣服图片的二维数组（5种衣服，每种4个状态）
        Bitmap[,] petClothes = new Bitmap[5, 4];

        // 存储穿戴衣服后的宠物图片数组
        Bitmap[] petWithClothes = new Bitmap[30];
        // 存储穿戴衣服后的拖拽状态宠物图片数组
        Bitmap[] petDragWithClothes = new Bitmap[3];
        // 存储穿戴衣服后的眨眼状态宠物图片数组
        Bitmap[] petBlinkWithClothes = new Bitmap[3];

        // 构造函数，初始化窗体
        public Form1()
        {
            // 初始化组件（设计器生成的代码）
            InitializeComponent();
            // 不在任务栏显示窗体
            this.ShowInTaskbar = false;

            // 初始化亮度调节定时器
            brightnessTimer = new Timer();
            // 设置定时器间隔为60000毫秒（1分钟）
            brightnessTimer.Interval = 60000;
            // 绑定定时器事件处理函数
            brightnessTimer.Tick += BrightnessTimer_Tick;

            // 初始化系统信息定时器
            systemInfoTimer = new Timer();
            systemInfoTimer.Interval = 5000; // 每5秒更新一次
            systemInfoTimer.Tick += SystemInfoTimer_Tick;

            // 初始化CPU性能计数器
            try
            {
                cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"无法初始化CPU计数器: {ex.Message}");
            }
        }

        #region 窗体事件重载方法

        // 重写窗体关闭事件，取消关闭并设置句柄状态
        protected override void OnClosing(CancelEventArgs e)
        {
            // 取消窗体关闭操作
            e.Cancel = true;
            // 调用基类的关闭方法
            base.OnClosing(e);
            // 设置句柄状态为false
            haveHandle = false;
        }

        // 重写窗体句柄创建事件，初始化窗体样式
        protected override void OnHandleCreated(EventArgs e)
        {
            // 初始化窗体样式
            InitializeStyles();
            // 调用基类的句柄创建方法
            base.OnHandleCreated(e);
            // 设置句柄状态为true
            haveHandle = true;
        }

        // 初始化窗体绘制样式，提高绘制性能
        private void InitializeStyles()
        {
            // 设置所有绘制在WM_PAINT消息中完成
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            // 设置控件由用户自己绘制
            SetStyle(ControlStyles.UserPaint, true);
            // 更新控件样式
            UpdateStyles();
        }

        // 重写创建参数属性，设置窗体为分层窗体（支持透明度）
        protected override CreateParams CreateParams
        {
            get
            {
                // 获取基类的创建参数
                CreateParams cParms = base.CreateParams;
                // 添加分层窗体扩展样式（支持透明效果）
                cParms.ExStyle |= 0x00080000; // WS_EX_LAYERED
                return cParms;
            }
        }

        #endregion

        #region 图像处理和显示方法

        // 设置窗体图像（核心显示方法，实现透明效果）
        public void SetBits(Bitmap bitmap)
        {
            // 如果没有有效句柄则返回
            if (!haveHandle) return;

            // 检查位图格式是否正确
            if (!Bitmap.IsCanonicalPixelFormat(bitmap.PixelFormat) || !Bitmap.IsAlphaPixelFormat(bitmap.PixelFormat))
                MessageBox.Show("Error Bitmap");

            // 声明Windows API所需的变量
            IntPtr oldBits = IntPtr.Zero;
            IntPtr screenDC = Win32.GetDC(IntPtr.Zero);
            IntPtr hBitmap = IntPtr.Zero;
            IntPtr memDc = Win32.CreateCompatibleDC(screenDC);

            try
            {
                // 设置窗体位置和大小参数
                Win32.Point topLoc = new Win32.Point(Left, Top);
                Win32.Size bitMapSize = new Win32.Size(bitmap.Width, bitmap.Height);
                Win32.BLENDFUNCTION blendFunc = new Win32.BLENDFUNCTION();
                Win32.Point srcLoc = new Win32.Point(0, 0);

                // 获取位图句柄
                hBitmap = bitmap.GetHbitmap(Color.FromArgb(0));
                // 选择对象到内存DC
                oldBits = Win32.SelectObject(memDc, hBitmap);

                // 设置混合参数
                blendFunc.BlendOp = Win32.AC_SRC_OVER;
                blendFunc.SourceConstantAlpha = 255;
                blendFunc.AlphaFormat = Win32.AC_SRC_ALPHA;
                blendFunc.BlendFlags = 0;

                // 更新分层窗体，实现透明显示效果
                Win32.UpdateLayeredWindow(Handle, screenDC, ref topLoc, ref bitMapSize, memDc, ref srcLoc, 0, ref blendFunc, Win32.ULW_ALPHA);
            }
            finally
            {
                // 清理资源
                if (hBitmap != IntPtr.Zero)
                {
                    Win32.SelectObject(memDc, oldBits);
                    Win32.DeleteObject(hBitmap);
                }
                Win32.ReleaseDC(IntPtr.Zero, screenDC);
                Win32.DeleteDC(memDc);
            }
        }

        // 为宠物穿上服装和帽子，并可选择调整亮度
        private Bitmap CombinedPic(Bitmap bottom, Bitmap top, int x, int y)
        {
            Bitmap bitmap = new Bitmap(bottom.Width, bottom.Height);
            Graphics g = Graphics.FromImage(bitmap);
            g.DrawImage(bottom, new Rectangle(0, 0, bottom.Width, bottom.Height), new Rectangle(0, 0, bottom.Width, bottom.Height), GraphicsUnit.Pixel);
            g.DrawImage(top, new Rectangle(x, y, top.Width, top.Height), new Rectangle(0, 0, top.Width, top.Height), GraphicsUnit.Pixel);
            return bitmap;
        }

        private Bitmap Dress(Bitmap img, int state)
        {
            Bitmap bitmap = new Bitmap(img.Width, img.Height);
            bitmap = img;
            if (clothesNum != -1)
            {
                bitmap = CombinedPic(bitmap, petClothes[clothesNum, state], 0, 0);
            }
            if (hatNum != -1)
            {
                bitmap = CombinedPic(bitmap, petHat[hatNum, state], 0, 0);
            }
            return bitmap;
        }
        #endregion

        #region 窗体加载事件

        // 窗体加载事件，初始化宠物图片资源
        private void Form1_Load(object sender, EventArgs e)
        {
            // 加载宠物普通状态图片
            pet[0] = new Bitmap(Application.StartupPath + "\\shell\\surface0000.png");
            pet[1] = new Bitmap(Application.StartupPath + "\\shell\\surface0001.png");
            pet[2] = new Bitmap(Application.StartupPath + "\\shell\\surface0002.png");
            pet[3] = new Bitmap(Application.StartupPath + "\\shell\\surface0003.png");
            pet[4] = new Bitmap(Application.StartupPath + "\\shell\\surface0004.png");
            pet[5] = new Bitmap(Application.StartupPath + "\\shell\\surface0005.png");
            pet[6] = new Bitmap(Application.StartupPath + "\\shell\\surface0006.png");
            pet[7] = new Bitmap(Application.StartupPath + "\\shell\\surface0007.png");
            pet[8] = new Bitmap(Application.StartupPath + "\\shell\\surface0008.png");
            pet[9] = new Bitmap(Application.StartupPath + "\\shell\\surface0009.png");

            // 加载宠物拖拽状态图片
            petDrag[0] = new Bitmap(Application.StartupPath + "\\shell\\surface0091.png");
            petDrag[1] = new Bitmap(Application.StartupPath + "\\shell\\surface0092.png");
            petDrag[2] = new Bitmap(Application.StartupPath + "\\shell\\surface0093.png");

            // 加载宠物眨眼状态图片
            petBlink[0] = new Bitmap(Application.StartupPath + "\\shell\\surface1003.png");
            petBlink[1] = new Bitmap(Application.StartupPath + "\\shell\\surface1004.png");

            // 加载帽子图片
            petHat[0, 0] = new Bitmap(Application.StartupPath + "\\shell\\surface3000.png");
            petHat[0, 1] = new Bitmap(Application.StartupPath + "\\shell\\surface3001.png");
            petHat[1, 0] = new Bitmap(Application.StartupPath + "\\shell\\surface3002.png");
            petHat[1, 1] = new Bitmap(Application.StartupPath + "\\shell\\surface3003.png");
            petHat[2, 0] = new Bitmap(Application.StartupPath + "\\shell\\surface3004.png");
            petHat[2, 1] = new Bitmap(Application.StartupPath + "\\shell\\surface3005.png");
            petHat[3, 0] = new Bitmap(Application.StartupPath + "\\shell\\surface3006.png");
            petHat[3, 1] = new Bitmap(Application.StartupPath + "\\shell\\surface3007.png");

            // 加载衣服图片
            petClothes[0, 0] = new Bitmap(Application.StartupPath + "\\shell\\surface3100.png");
            petClothes[0, 1] = new Bitmap(Application.StartupPath + "\\shell\\surface3101.png");
            petClothes[0, 2] = new Bitmap(Application.StartupPath + "\\shell\\surface3102.png");
            petClothes[0, 3] = new Bitmap(Application.StartupPath + "\\shell\\surface3103.png");
            petClothes[1, 0] = new Bitmap(Application.StartupPath + "\\shell\\surface3200.png");
            petClothes[1, 1] = new Bitmap(Application.StartupPath + "\\shell\\surface3201.png");
            petClothes[1, 2] = new Bitmap(Application.StartupPath + "\\shell\\surface3202.png");
            petClothes[1, 3] = new Bitmap(Application.StartupPath + "\\shell\\surface3203.png");

            // 动态添加自动亮度调节菜单项（如果设计器方法仍然出错）
            if (自动调节亮度ToolStripMenuItem == null)
            {
                自动调节亮度ToolStripMenuItem = new ToolStripMenuItem();
                自动调节亮度ToolStripMenuItem.Name = "自动调节亮度ToolStripMenuItem";
                自动调节亮度ToolStripMenuItem.Text = "自动调节亮度";
                自动调节亮度ToolStripMenuItem.CheckOnClick = true;
                自动调节亮度ToolStripMenuItem.Click += 自动调节亮度ToolStripMenuItem_Click;

                // 插入到眨眼和衣柜之间
                rightClickMenu.Items.Insert(2, 自动调节亮度ToolStripMenuItem);
            }
            else
            {
                // 确保事件处理程序已绑定（防止设计器问题）
                自动调节亮度ToolStripMenuItem.Click += 自动调节亮度ToolStripMenuItem_Click;
            }

            // 初始化时确保自动亮度调节是关闭的
            autoBrightnessEnabled = false;
            if (自动调节亮度ToolStripMenuItem != null)
            {
                自动调节亮度ToolStripMenuItem.Checked = false;
            }


            // 为所有图片穿上服装
            DressAll();
            // 显示第一帧宠物图片
            SetBits(petWithClothes[0]);
        }

        #endregion

        #region 时间和亮度调节功能

        // 获取当前时间段
        private TimePeriod GetCurrentTimePeriod()
        {
            // 获取当前小时数
            int hour = DateTime.Now.Hour;

            // 根据小时数判断时间段
            if (hour >= 6 && hour < 12)
                return TimePeriod.Morning; // 早晨 6:00-11:59
            else if (hour >= 12 && hour < 17)
                return TimePeriod.Noon; // 中午 12:00-16:59
            else if (hour >= 17 && hour < 21)
                return TimePeriod.Evening; // 傍晚 17:00-20:59
            else
                return TimePeriod.Night; // 夜晚 21:00-5:59
        }

        // 根据时间段获取亮度值 (0-100)
        private int GetBrightnessByTimePeriod(TimePeriod period)
        {
            // 根据不同时间段返回对应的亮度值
            switch (period)
            {
                case TimePeriod.Morning:
                    return 70;  // 早晨亮度70%
                case TimePeriod.Noon:
                    return 100; // 中午亮度100%
                case TimePeriod.Evening:
                    return 60;  // 傍晚亮度60%
                case TimePeriod.Night:
                    return 40;  // 夜晚亮度40%（从30%提高到40%）
                default:
                    return 60;
            }
        }

        // 设置屏幕亮度 (通过重新渲染图像来调整亮度)
        private void SetBrightness(int brightness)
        {
            // 限制亮度值范围在30-100之间
            if (brightness < 30) brightness = 30;
            if (brightness > 100) brightness = 100;

            // 通过重新渲染图像来调整亮度（0.3到1.0的范围）
            float brightnessFactor = brightness / 100.0f;
        }

        // 亮度定时器事件处理，定期检查并调整亮度
        private void BrightnessTimer_Tick(object sender, EventArgs e)
        {
            // 如果自动亮度调节功能开启
            if (autoBrightnessEnabled)
            {
                // 获取当前时间段
                TimePeriod currentPeriod = GetCurrentTimePeriod();
                // 获取目标亮度值
                int targetBrightness = GetBrightnessByTimePeriod(currentPeriod);
                // 设置亮度
                SetBrightness(targetBrightness);
            }
        }

        // 切换自动亮度调节功能
        private void ToggleAutoBrightness(bool enable)
        {
            // 设置自动亮度调节开关状态
            autoBrightnessEnabled = enable;

            // 同步菜单项的选中状态
            if (自动调节亮度ToolStripMenuItem != null)
            {
                自动调节亮度ToolStripMenuItem.Checked = enable;
            }

            // 如果开启自动亮度调节
            if (autoBrightnessEnabled)
            {
                // 启动定时器
                brightnessTimer.Start();
                // 立即应用一次亮度设置
                TimePeriod currentPeriod = GetCurrentTimePeriod();
                int targetBrightness = GetBrightnessByTimePeriod(currentPeriod);
                SetBrightness(targetBrightness);
            }
            else
            {
                // 停止定时器
                brightnessTimer.Stop();
                // 恢复默认亮度（100%）
                SetBrightness(100);
            }
        }

        #endregion

        #region 系统信息获取方法

        // 获取CPU使用率
        private float GetCpuUsage()
        {
            try
            {
                if (cpuCounter != null)
                {
                    return cpuCounter.NextValue();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"获取CPU使用率失败: {ex.Message}");
            }
            return 0;
        }

        // 获取内存使用情况
        private (long totalMemory, long availableMemory, long usedMemory) GetMemoryInfo()
        {
            try
            {
                using (var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_OperatingSystem"))
                {
                    foreach (ManagementObject obj in searcher.Get())
                    {
                        long totalMemory = Convert.ToInt64(obj["TotalVisibleMemorySize"]) * 1024; // 转换为字节
                        long freeMemory = Convert.ToInt64(obj["FreePhysicalMemory"]) * 1024; // 转换为字节
                        long usedMemory = totalMemory - freeMemory;

                        return (totalMemory, freeMemory, usedMemory);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"获取内存信息失败: {ex.Message}");
            }

            return (0, 0, 0);
        }

        // 获取磁盘使用情况
        private Dictionary<string, (long totalSize, long freeSpace, long usedSpace)> GetDiskInfo()
        {
            var diskInfo = new Dictionary<string, (long, long, long)>();

            try
            {
                DriveInfo[] drives = DriveInfo.GetDrives();
                foreach (DriveInfo drive in drives)
                {
                    if (drive.IsReady && drive.DriveType == DriveType.Fixed)
                    {
                        long totalSize = drive.TotalSize;
                        long freeSpace = drive.TotalFreeSpace;
                        long usedSpace = totalSize - freeSpace;

                        diskInfo[drive.Name] = (totalSize, freeSpace, usedSpace);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"获取磁盘信息失败: {ex.Message}");
            }

            return diskInfo;
        }

        // 格式化字节大小显示
        private string FormatBytes(long bytes)
        {
            string[] suffixes = { "B", "KB", "MB", "GB", "TB" };
            int counter = 0;
            decimal number = bytes;

            while (Math.Round(number / 1024) >= 1)
            {
                number = number / 1024;
                counter++;
            }

            return string.Format("{0:n1} {1}", number, suffixes[counter]);
        }

        // 格式化百分比显示
        private string FormatPercentage(float percentage)
        {
            return $"{percentage:F1}%";
        }

        // 显示系统信息（保存信息并更新显示）- 显示所有磁盘信息版本
        private void DisplaySystemInfo()
        {
            try
            {
                Console.WriteLine("正在获取系统信息...");
                // 获取CPU使用率
                float cpuUsage = GetCpuUsage();

                // 获取内存信息
                var (totalMemory, availableMemory, usedMemory) = GetMemoryInfo();

                // 获取磁盘信息
                var diskInfo = GetDiskInfo();

                // 构建简洁的信息字符串（适合在信息窗体上显示）
                StringBuilder infoBuilder = new StringBuilder();
                infoBuilder.AppendLine($"CPU: {FormatPercentage(cpuUsage)}");
                infoBuilder.AppendLine($"内存: {FormatPercentage((float)usedMemory / totalMemory * 100)}");

                // 显示所有磁盘信息（如果空间足够）
                int diskCount = 0;
                foreach (var disk in diskInfo)
                {
                    if (diskCount >= 2) break; // 最多显示两个磁盘信息，避免信息过多
                    string driveName = disk.Key.Replace("\\", "");
                    var (totalSize, freeSpace, usedSpace) = disk.Value;
                    float diskUsage = (float)usedSpace / totalSize * 100;
                    infoBuilder.AppendLine($"{driveName}: {FormatPercentage(diskUsage)}");
                    diskCount++;
                }

                // 保存信息用于显示
                currentSystemInfo = infoBuilder.ToString();

                // 更新信息显示
                UpdateSystemInfoDisplay();

                // 同时输出到控制台（用于调试）
                Console.WriteLine($"系统信息更新: CPU={FormatPercentage(cpuUsage)}, 内存={FormatPercentage((float)usedMemory / totalMemory * 100)}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"显示系统信息时出错: {ex.Message}");
            }
        }

        // 系统信息定时器事件处理
        private void SystemInfoTimer_Tick(object sender, EventArgs e)
        {
            if (showSystemInfo)
            {
                DisplaySystemInfo();
            }
        }

        // 显示系统信息菜单项点击事件
        private void 显示系统信息ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ToolStripMenuItem item = sender as ToolStripMenuItem;
            bool isChecked = item.Checked;

            // 切换系统信息显示状态
            showSystemInfoOverlay = item.Checked;

            if (showSystemInfoOverlay)
            {
                Console.WriteLine("显示系统信息已启用");
                // 创建并显示系统信息窗体
                CreateSystemInfoForm();
                // 开始显示系统信息
                showSystemInfo = true;
                systemInfoTimer.Start();
                DisplaySystemInfo(); // 立即显示一次
            }
            else
            {
                Console.WriteLine("显示系统信息已禁用");
                // 停止显示系统信息
                showSystemInfo = false;
                systemInfoTimer.Stop();
                // 隐藏信息窗体
                if (systemInfoForm != null)
                {
                    systemInfoForm.Hide();
                }
                currentSystemInfo = "";
            }
        }

        // 创建系统信息显示窗体
        private void CreateSystemInfoForm()
        {
            if (systemInfoForm == null)
            {
                systemInfoForm = new Form();
                systemInfoForm.FormBorderStyle = FormBorderStyle.None;
                systemInfoForm.BackColor = Color.Black;
                systemInfoForm.Opacity = 0.7;
                systemInfoForm.TopMost = true;
                systemInfoForm.ShowInTaskbar = false;
                systemInfoForm.Size = new Size(150, 100); // 进一步增加高度

                // 设置为工具窗口以避免任务栏显示
                System.Reflection.FieldInfo f = typeof(Form).GetField("exStyle", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
                if (f != null)
                {
                    f.SetValue(systemInfoForm, 0x80); // WS_EX_TOOLWINDOW
                }

                systemInfoLabel = new Label();
                systemInfoLabel.ForeColor = Color.White;
                systemInfoLabel.BackColor = Color.Transparent;
                systemInfoLabel.AutoSize = false;
                systemInfoLabel.TextAlign = ContentAlignment.MiddleCenter;
                systemInfoLabel.Dock = DockStyle.Fill;
                systemInfoLabel.Font = new Font("Arial", 9, FontStyle.Bold);

                systemInfoForm.Controls.Add(systemInfoLabel);

                // 设置初始位置（宠物窗体旁边）
                UpdateSystemInfoFormPosition();
            }
        }

        // 更新信息窗体位置
        private void UpdateSystemInfoFormPosition()
        {
            if (systemInfoForm != null)
            {
                // 将信息窗体定位在宠物窗体旁边
                systemInfoForm.Location = new Point(this.Right + 10, this.Top);
            }
        }

        // 更新系统信息显示
        private void UpdateSystemInfoDisplay()
        {
            if (systemInfoForm != null && systemInfoLabel != null && showSystemInfoOverlay)
            {
                systemInfoLabel.Text = currentSystemInfo;
                UpdateSystemInfoFormPosition();
                if (!systemInfoForm.Visible)
                {
                    systemInfoForm.Show();
                }
            }
            else if (systemInfoForm != null)
            {
                systemInfoForm.Hide();
            }
        }
        #endregion
        

        #region 鼠标拖拽功能

        // 鼠标按下事件，开始拖拽
        private void Form1_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            // 如果按下的是鼠标左键
            if (e.Button == System.Windows.Forms.MouseButtons.Left)
            {
                // 设置拖拽标志为true
                bFormDragging = true;
                // 记录鼠标点击位置
                oPointClicked = new Point(e.X, e.Y);
                // 设置拖拽定时器间隔为110毫秒
                tmrDrag.Interval = 110;
                // 启动拖拽定时器
                tmrDrag.Enabled = true;
            }
        }

        // 鼠标释放事件，结束拖拽
        private void Form1_MouseUp(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            // 如果释放的是鼠标左键
            if (e.Button == System.Windows.Forms.MouseButtons.Left)
            {
                // 设置拖拽标志为false
                bFormDragging = false;
                // 停止拖拽定时器
                tmrDrag.Enabled = false;
                // 显示普通状态的第一帧宠物图片
                SetBits(petWithClothes[0]);
            }
        }

        // 鼠标移动事件，实现窗体拖拽
        private void Form1_MouseMove(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            // 如果正在拖拽
            if (bFormDragging)
            {
                // 声明移动目标点
                Point oMoveToPoint = default(Point);
                // 将鼠标当前位置转换为屏幕坐标
                oMoveToPoint = PointToScreen(new Point(e.X, e.Y));
                // 计算窗体新位置
                oMoveToPoint.Offset(oPointClicked.X * -1, (oPointClicked.Y + SystemInformation.CaptionHeight + SystemInformation.BorderSize.Height) * -1 + 24);
                // 设置窗体位置
                Location = oMoveToPoint;

                // 更新系统信息窗体位置
                if (showSystemInfoOverlay)
                {
                    UpdateSystemInfoFormPosition();
                }
            }
        }

        // 拖拽定时器事件，实现拖拽动画
        private void tmrDrag_Tick(object sender, EventArgs e)
        {
            if (dragFrame < 2)
            {
                SetBits(petDragWithClothes[dragFrame]);
                dragFrame += 1;
            }
            else
            {
                SetBits(petDragWithClothes[dragFrame]);
                dragFrame = 0;
            }
        }

        #endregion

        #region 菜单事件处理

        // 退出菜单项点击事件
        private void 退出ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // 退出应用程序
            Application.Exit();
        }

        // 眨眼菜单项点击事件
        private void 眨眼ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // 设置眨眼定时器间隔为40毫秒
            tmrBlink.Interval = 40;
            // 启动眨眼定时器
            tmrBlink.Start();
        }

        // 眨眼定时器事件，实现眨眼动画
        private void tmrBlink_Tick(object sender, EventArgs e)
        {
            if (blinkFrame < 2)
            {
                SetBits(petBlinkWithClothes[blinkFrame]);
                blinkFrame += 1;
            }
            else
            {
                SetBits(petWithClothes[0]);
                blinkFrame = 0;
                tmrBlink.Stop();
            }
        }

        // 帽子菜单项点击事件
        private void 帽子ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // 获取菜单项选中状态
            bool itemChecked = (sender as ToolStripMenuItem).Checked;
            // 如果之前是选中状态，则取消帽子
            if (itemChecked)
            {
                hatNum = -1;
            }
            else
            {
                // 否则设置帽子编号为菜单项索引
                hatNum = this.衣柜ToolStripMenuItem.DropDownItems.IndexOf(sender as ToolStripMenuItem);
            }

            // 取消所有帽子的选中状态
            this.圣诞帽子ToolStripMenuItem.Checked = false;
            this.樱花帽子ToolStripMenuItem.Checked = false;
            this.水手帽ToolStripMenuItem.Checked = false;
            this.风车帽子ToolStripMenuItem.Checked = false;
            // 切换当前帽子的选中状态
            (sender as ToolStripMenuItem).Checked = !itemChecked;
            // 重新为所有图片穿上服装
            DressAll();
            // 显示更新后的图片
            if (showSystemInfoOverlay)
            {
                UpdateSystemInfoDisplay();
            }
            SetBits(petWithClothes[0]);
        }

        // 衣服菜单项点击事件
        private void 衣服ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // 获取菜单项选中状态
            bool itemChecked = (sender as ToolStripMenuItem).Checked;
            // 如果之前是选中状态，则取消衣服
            if (itemChecked)
            {
                clothesNum = -1;
            }
            else
            {
                // 否则设置衣服编号为菜单项索引减去4（因为帽子在前4个）
                clothesNum = this.衣柜ToolStripMenuItem.DropDownItems.IndexOf(sender as ToolStripMenuItem) - 4;
            }

            // 取消所有衣服的选中状态
            this.圣诞衣服ToolStripMenuItem.Checked = false;
            this.和服ToolStripMenuItem.Checked = false;
            // 切换当前衣服的选中状态
            (sender as ToolStripMenuItem).Checked = !itemChecked;
            // 重新为所有图片穿上服装
            DressAll();
            // 显示更新后的图片
            if (showSystemInfoOverlay)
            {
                UpdateSystemInfoDisplay();
            }
            SetBits(petWithClothes[0]);
        }

        // 自动调节亮度菜单项点击事件
        private void 自动调节亮度ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // 获取菜单项
            ToolStripMenuItem item = sender as ToolStripMenuItem;

            // 根据菜单项的选中状态来切换自动亮度调节功能
            // 注意：由于CheckOnClick=true，选中状态已经自动切换了
            ToggleAutoBrightness(item.Checked);
        }

        #endregion

        #region 图像处理辅助方法

        // 为所有宠物图片穿上当前选中的服装和帽子
        private void DressAll()
        {
            int i;
            for (i = 0; i < 10; i++)
            {
                petWithClothes[i] = Dress(pet[i], (int)PetStates.General);
            }
            for (i = 0; i < 3; i++)
            {
                petDragWithClothes[i] = Dress(petDrag[i], (int)PetStates.Drag);
            }
            for (i = 0; i < 2; i++)
            {
                petBlinkWithClothes[i] = Dress(petBlink[i], (int)PetStates.General);
            }
        }

        // 恢复默认亮度的方法
        private void RestoreDefaultBrightness()
        {
            // 恢复窗体透明度到默认值（100%）
            this.Opacity = 1.0;

            // 确保定时器停止
            if (brightnessTimer != null && brightnessTimer.Enabled)
            {
                brightnessTimer.Stop();
            }

            // 重置亮度调节标志
            autoBrightnessEnabled = false;
        }

        #endregion
    }
}